Computer Select (Limited Edition)

home *** CD-ROM | disk | FTP | other *** search

/ Computer Select (Limited Edition) / Computer Select.iso / pcmag / v10n19 / talk.asm < prev next >

Wrap

Assembly Source File | 1991-10-15 | 20.9 KB | 549 lines

title TALK --- Simple terminal emulator page 55,132 .lfcond ;list false conditionals too ; TALK.ASM --- Simple terminal emulator program ; that demonstrates use of the DOS 5 Task Switcher API. ; Copyright (c) 1991 Ray Duncan ; ; Set the equates COM1 and ECHO to TRUE or FALSE as appropriate ; for your machine. This program does not set baud rates or ; other communications parameters; use the MODE command instead. ; Exit from TALK.EXE by entering Alt-X. stdout equ 1 ; standard output handle cr equ 0dh ; ASCII carriage return lf equ 0ah ; ASCII line feed AltX equ 02dh ; keycode for Alt-X bufsiz equ 4096 ; size of serial port buffer true equ -1 false equ 0 com1 equ false ; Use COM1 if nonzero com2 equ not com1 ; Use COM2 if nonzero echo equ false ; FALSE=full-duplex, ; TRUE=half-duplex pic_mask equ 21h ; 8259 int. mask port pic_eoi equ 20h ; 8259 EOI port if com1 com_data equ 03f8h ; port assignments for COM1 com_ier equ 03f9h com_mcr equ 03fch com_sts equ 03fdh com_int equ 0ch ; COM1 interrupt number int_mask equ 10h ; IRQ4 mask for 8259 endif if com2 com_data equ 02f8h ; port assignments for COM2 com_ier equ 02f9h com_mcr equ 02fch com_sts equ 02fdh com_int equ 0bh ; COM2 interrupt number int_mask equ 08h ; IRQ3 mask for 8259 endif _DATA segment word public 'DATA' in_char db 0 ; PC keyboard input char. in_flag db 0 ; <>0 if char waiting msg1 db cr,lf,'Terminal emulator running...',cr,lf msg1_len equ $-msg1 msg2 db cr,lf,'Exit from terminal emulator.',cr,lf msg2_len equ $-msg2 oldcomm dd 0 ; original contents of serial ; port interrupt vector switcher dd 0 ; address of task switcher's ; service entry point swvers dd 0 ; pointer to SWVERSION structure ; returned by task switcher cbinfo label word ; switcher callback info structure cbnext dd 0 ; addr of next structure in chain cbentry dd callback ; entry point for notify function dd 0 ; reserved cbapi dd apiinfo ; addr of list of api info strucs apiinfo dw 0 ; empty list of api info structures hooked dw 0 ; nonzero if we are hooked into ; switcher notification chain asc_in dw 0 ; input pointer to ring buffer asc_out dw 0 ; output pointer to ring buffer asc_buf db bufsiz dup (?) ; communications buffer _DATA ends _TEXT segment word public 'CODE' assume cs:_TEXT,ds:_DATA,ss:_STK talk proc far mov ax,_DATA ; make our data addressable mov ds,ax mov es,ax call hook ; try and hook switcher jc talk1 ; jump, function failed mov hooked,-1 ; set flag that we are chained talk1: call asc_enb ; enable communications port mov dx,offset msg1 ; display message mov cx,msg1_len ; 'Terminal emulator running' mov bx,stdout ; BX = standard output handle mov ah,40h ; Fxn 40H = write file or device int 21h ; transfer to MS-DOS talk2: call pc_stat ; keyboard character waiting? jz talk4 ; nothing waiting, jump call pc_in ; read keyboard character cmp al,0 ; is it a function key? jne talk3 ; not function key, jump call pc_in ; function key, get 2nd part cmp al,AltX ; was it Alt-X? je talk5 ; yes, terminate program push ax ; no, send to comm port xor al,al ; send lead byte (0) call com_out pop ax ; send function key code call com_out jmp talk2 ; get another key talk3: if echo ; keyboard character received push ax ; if half-duplex, echo call pc_out ; character to PC display pop ax endif call com_out ; send char to serial port talk4: call com_stat ; serial port input waiting? jz talk2 ; nothing waiting, jump call com_in ; read char from serial port call pc_out ; send it to PC display jmp talk4 ; see if any more waiting talk5: call asc_dsb ; release comm hardware cmp hooked,0 ; did we hook task switcher? je talk6 ; no, jump call unhook ; release switcher hooks talk6: mov dx,offset msg2 ; display farewell message mov cx,msg2_len ; DX=addr, CX=length mov bx,stdout ; BX = standard output handle mov ah,40h ; Fxn 40H = write device int 21h ; transfer to MS-DOS mov ax,4c00h ; terminate program with int 21h ; return code = 0 talk endp ; The variable OLDMUX holds the previous contents of the Int 2FH ; vector. The variable is in the code segment so that it is ; addressable at interrupt time without changing DS. oldmux dd 0 ; prev owner of Int 2FH ; ; HOOK - Hook switcher notification chain and multiplex interrupt. ; ; Call with: Nothing ; Returns: Carry = clear if switcher was hooked ; Carry = set if switcher not present or could ; not be hooked. ; Destroys: AX, BX, CX, DX, DI, ES ; hook proc near xor bx,bx ; check if switcher present mov di,bx ; BX, ES:DI must be zero mov es,bx mov ax,4b02h ; multiplex function 4b02h int 2fh ; is detect switcher call mov ax,es ; check for ES:DI=0 or ax,di jz hook2 ; jump if no switcher mov word ptr switcher,di ; save address of switcher mov word ptr switcher+2,es ; service entry point xor ax,ax ; get pointer to switcher's call [switcher] ; version data structure jc hook2 ; jump, function failed mov word ptr swvers,bx ; otherwise pointer was mov word ptr swvers+2,es ; returned in ES:BX cmp word ptr es:[bx],1 ; check switcher protocol version jne hook2 ; we insist on version 1.0 or we cmp word ptr es:[bx+2],0 ; don't hook notification chain jne hook2 ; jump, not 1.0 mov ax,4 ; now hook notification chain mov di,ds ; switcher function = 4 mov es,di ; ES:DI = addr of switcher mov di,offset _DATA:cbinfo ; callback info structure call [switcher] ; call switcher entry point jc hook2 ; jump, function failed mov ax,352fh ; get current vector for int 21h ; multiplex interrupt 2FH mov word ptr oldmux+2,es ; and save it mov word ptr oldmux,bx push ds ; save our data segment mov ax,cs ; set DS:DX = address mov ds,ax ; of our multiplex handler mov dx,offset muxisr ; to hook Int 2FH mov ax,252fh ; Fxn 25H = set vector int 21h ; transfer to MS-DOS pop ds ; restore data segment clc ; return carry = clear ret ; if switcher was hooked hook2: stc ; return carry = set ret ; if switcher not hooked hook endp ; ; UNHOOK - Release switcher notification chain and multiplex interrupt. ; ; Call with: Nothing ; Returns: Nothing ; Destroys: AX, DX, DI, ES ; unhook proc near push ds ; save our data segment lds dx,oldmux ; load address of previous ; multiplex interrupt owner mov ax,252fh ; Fxn 25H = set vector int 21h ; transfer to MS-DOS pop ds ; restore data segment mov ax,5 ; unhook from notify chain mov di,ds ; switcher function = 5 mov es,di ; ES:DI = address of mov di,offset _DATA:cbinfo ; callback info structure call [switcher] ; call switcher entry point ret unhook endp ; ; MUXISR - Handler for multiplex interrupt. ; ; Call with: AH = multiplex number, other registers vary. ; Returns: ES:BX = address of callback info structure ; if multiplex function 4BH subfunction 01H detected, ; otherwise changes nothing, chains to previous owner. ; Destroys: Nothing ; muxisr proc far cmp ax,4b01h ; is this Build Notify Chain? je mux2 ; yes, process it jmp [oldmux] ; no, chain to old handler mux2: push ds ; save updated switcher push ax ; entry point address mov ax,_DATA mov ds,ax mov word ptr switcher+2,cx mov word ptr switcher,dx pop ax pop ds pushf ; call down through the call [oldmux] ; multiplex handler chain push ds ; now save address of next push ax ; guy's callback info structure mov ax,_DATA ; in our callback info structure mov ds,ax mov word ptr cbnext,bx mov word ptr cbnext+2,es mov es,ax ; let ES:BX = address of mov bx,offset _DATA:cbinfo ; our callback info structure pop ax ; and pass it back to switcher pop ds iret ; return from multiplex interrupt muxisr endp ; ; CALLBACK - Switcher callback function installed by HOOK and MUXISR. ; Looks for session switch notifications and refuses same. ; ; Call with: AX = notification type, other registers vary. ; Returns: AX <> 0 if Query Suspend Session or Suspend Session ; notifications, otherwise AX = 0. ; Destroys: Nothing ; callback proc far cmp ax,1 ; is it Query Suspend callback? je callb2 ; yes, return 1 to block suspend cmp ax,2 ; is it Suspend Session callback? je callb2 ; yes, return 1 to block suspend xor ax,ax ; else return success callb2: retf callback endp ; ; COM_STAT - Check communications port status ; ; Call with: Nothing ; Returns: Zero flag = false if character ready ; Zero flag = true if no character waiting ; Destroys: Nothing ; com_stat proc near push ax ; save AX mov ax,asc_in ; compare ring buffer pointers cmp ax,asc_out ; to set Zero flag pop ax ; restore AX ret ; return to caller com_stat endp ; ; COM_IN - Get character from serial port ; ; Call with: Nothing ; Returns: AL = character ; Destroys: Nothing ; com_in proc near push bx ; save register BX com_in1: ; if no char waiting, wait mov bx,asc_out ; until one is received cmp bx,asc_in je com_in1 ; jump, nothing waiting mov al,[bx+asc_buf] ; extract char from buffer inc bx ; update buffer pointer cmp bx,bufsiz ; time to wrap pointer? jne com_in2 ; no, jump xor bx,bx ; yes, reset pointer com_in2: mov asc_out,bx ; store updated pointer pop bx ; restore register BX ret ; and return to caller com_in endp ; ; COM_OUT - Transmit character to serial port ; ; Call with: AL = character ; Returns: Nothing ; Destroys: Nothing ; com_out proc near push dx ; save register DX push ax ; save character to send mov dx,com_sts ; DX = status port address com_out1: ; check if transmit buffer in al,dx ; is empty (TBE bit = set) and al,20h jz com_out1 ; no, must wait pop ax ; retrieve character mov dx,com_data ; DX = data port address out dx,al ; transmit the character pop dx ; restore register DX ret ; and return to caller com_out endp ; ; PC_STAT - Get keyboard status ; ; Call with: Nothing ; Returns: Zero flag = false if character ready ; Zero flag = true if no character waiting ; Destroys: DX ; pc_stat proc near mov al,in_flag ; if character already or al,al ; waiting, return status jnz pc_stat1 ; in Zero flag mov ah,6 ; otherwise call DOS to mov dl,0ffh ; determine keyboard status int 21h jz pc_stat1 ; jump if no key ready mov in_char,al ; got key, save it for mov in_flag,0ffh ; "pc_in" routine pc_stat1: ; return to caller with ret ; status in Zero flag pc_stat endp ; ; PC_IN - Get character from keyboard ; ; Call with: Nothing ; Returns: AL = character ; Destroys: DX ; pc_in proc near mov al,in_flag ; key already waiting? or al,al jnz pc_in1 ; yes,return it to caller call pc_stat ; no, try and read char. jmp pc_in pc_in1: mov in_flag,0 ; clear char. waiting flag mov al,in_char ; and return AL = char. ret pc_in endp ; ; PC_OUT - Send character to PC screen ; ; Call with: AL = character ; Returns: Nothing ; Destroys: AX, DX ; pc_out proc near mov dl,al ; DL = char to output mov ah,6 ; function 6 = direct I/O int 21h ; transfer to MS-DOS ret ; return to caller pc_out endp ; ; ASC_ENB - Enable comm port, capture communications interrupt ; ; Call with: Nothing ; Returns: Nothing ; Destroys: AX, BX, DX, ES ; asc_enb proc near mov ax,3500h+com_int ; save address of previous int 21h ; owner of comm interrupt mov word ptr oldcomm+2,es ; function 35H returns mov word ptr oldcomm,bx ; vector in ES:BX ; install our comm handler push ds ; save our data segment mov ax,cs ; DS:DX = address of mov ds,ax ; comm interrupt handler mov dx,offset asc_isr mov ax,2500h+com_int ; Fxn 25H = set vector int 21h ; transfer to MS-DOS pop ds ; restore data segment mov dx,com_mcr ; set modem control reg. mov al,0bh ; DTR and OUT2 bits out dx,al ; to enable interrupts mov dx,com_ier ; set interrupt enable mov al,1 ; register on serial out dx,al ; port controller in al,pic_mask ; read 8259 interrupt mask and al,not int_mask ; set mask for COM port out pic_mask,al ; write new 8259 mask ret ; back to caller asc_enb endp ; ; ASC_DSB - Release communications interrupt, disable comm hardware ; ; Call with: Nothing ; Returns: Nothing ; Destroys: AX, DX ; asc_dsb proc near in al,pic_mask ; read 8259 interrupt mask or al,int_mask ; reset mask for COM port out pic_mask,al ; write new 8259 mask push ds ; save our data segment lds dx,oldcomm ; DX:DX = address of prev ; comm interrupt handler mov ax,2500h+com_int ; Fxn 25H = set vector int 21h ; transfer to MS-DOS pop ds ; restore data segment ret ; back to caller asc_dsb endp ; ; ASC_ISR - Communications interrupt service routine ; Call with: Nothing ; Returns: Nothing ; Destroys: Nothing ; asc_isr proc far sti ; turn interrupts back on push ax ; save registers push bx push dx push ds mov ax,_DATA ; make our data segment mov ds,ax ; addressable mov dx,com_data ; DX = data port address in al,dx ; read this character mov bx,asc_in ; get buffer pointer mov [asc_buf+bx],al ; store this character inc bx ; bump pointer cmp bx,bufsiz ; time for wrap? jne asc_isr1 ; no, jump xor bx,bx ; yes, reset pointer asc_isr1: ; store updated pointer mov asc_in,bx mov al,20h ; send EOI to 8259 out pic_eoi,al pop ds ; restore all registers pop dx pop bx pop ax iret ; return from interrupt asc_isr endp _TEXT ends _STK segment para stack 'STACK' db 128 dup (?) _STK ends end talk